(function (f) {
  if (typeof exports === "object" && typeof module !== "undefined") {
    module.exports = f();
  } else if (typeof define === "function" && define.amd) {
    define([], f);
  } else {
    var g;
    if (typeof window !== "undefined") {
      g = window;
    } else if (typeof global !== "undefined") {
      g = global;
    } else if (typeof self !== "undefined") {
      g = self;
    } else {
      g = this;
    }
    g.Qs = f();
  }
})(function () {
  var define, module, exports;
  return (function () {
    function r(e, n, t) {
      function o(i, f) {
        if (!n[i]) {
          if (!e[i]) {
            var c = "function" == typeof require && require;
            if (!f && c) return c(i, !0);
            if (u) return u(i, !0);
            var a = new Error("Cannot find module '" + i + "'");
            throw ((a.code = "MODULE_NOT_FOUND"), a);
          }
          var p = (n[i] = { exports: {} });
          e[i][0].call(
            p.exports,
            function (r) {
              var n = e[i][1][r];
              return o(n || r);
            },
            p,
            p.exports,
            r,
            e,
            n,
            t
          );
        }
        return n[i].exports;
      }
      for (
        var u = "function" == typeof require && require, i = 0;
        i < t.length;
        i++
      )
        o(t[i]);
      return o;
    }
    return r;
  })()(
    {
      1: [
        function (require, module, exports) {
          "use strict";
          var replace = String.prototype.replace,
            percentTwenties = /%20/g,
            Format = { RFC1738: "RFC1738", RFC3986: "RFC3986" };
          module.exports = {
            default: Format.RFC3986,
            formatters: {
              RFC1738: function (e) {
                return replace.call(e, percentTwenties, "+");
              },
              RFC3986: function (e) {
                return String(e);
              },
            },
            RFC1738: Format.RFC1738,
            RFC3986: Format.RFC3986,
          };
        },
        {},
      ],
      2: [
        function (require, module, exports) {
          "use strict";
          var stringify = require(4),
            parse = require(3),
            formats = require(1);
          module.exports = {
            formats: formats,
            parse: parse,
            stringify: stringify,
          };
        },
        { 1: 1, 3: 3, 4: 4 },
      ],
      3: [
        function (require, module, exports) {
          "use strict";
          var utils = require(5),
            has = Object.prototype.hasOwnProperty,
            isArray = Array.isArray,
            defaults = {
              allowDots: !1,
              allowEmptyArrays: !1,
              allowPrototypes: !1,
              allowSparse: !1,
              arrayLimit: 20,
              charset: "utf-8",
              charsetSentinel: !1,
              comma: !1,
              decodeDotInKeys: !1,
              decoder: utils.decode,
              delimiter: "&",
              depth: 5,
              duplicates: "combine",
              ignoreQueryPrefix: !1,
              interpretNumericEntities: !1,
              parameterLimit: 1e3,
              parseArrays: !0,
              plainObjects: !1,
              strictNullHandling: !1,
            },
            interpretNumericEntities = function (e) {
              return e.replace(/&#(\d+);/g, function (e, t) {
                return String.fromCharCode(parseInt(t, 10));
              });
            },
            parseArrayValue = function (e, t) {
              return e && "string" == typeof e && t.comma && e.indexOf(",") > -1
                ? e.split(",")
                : e;
            },
            isoSentinel = "utf8=%26%2310003%3B",
            charsetSentinel = "utf8=%E2%9C%93",
            parseValues = function parseQueryStringValues(e, t) {
              var r = { __proto__: null },
                a = t.ignoreQueryPrefix ? e.replace(/^\?/, "") : e;
              a = a.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
              var i,
                o = t.parameterLimit === 1 / 0 ? void 0 : t.parameterLimit,
                l = a.split(t.delimiter, o),
                s = -1,
                n = t.charset;
              if (t.charsetSentinel)
                for (i = 0; i < l.length; ++i)
                  0 === l[i].indexOf("utf8=") &&
                    (l[i] === charsetSentinel
                      ? (n = "utf-8")
                      : l[i] === isoSentinel && (n = "iso-8859-1"),
                    (s = i),
                    (i = l.length));
              for (i = 0; i < l.length; ++i)
                if (i !== s) {
                  var p,
                    c,
                    d = l[i],
                    u = d.indexOf("]="),
                    y = -1 === u ? d.indexOf("=") : u + 1;
                  -1 === y
                    ? ((p = t.decoder(d, defaults.decoder, n, "key")),
                      (c = t.strictNullHandling ? null : ""))
                    : ((p = t.decoder(
                        d.slice(0, y),
                        defaults.decoder,
                        n,
                        "key"
                      )),
                      (c = utils.maybeMap(
                        parseArrayValue(d.slice(y + 1), t),
                        function (e) {
                          return t.decoder(e, defaults.decoder, n, "value");
                        }
                      ))),
                    c &&
                      t.interpretNumericEntities &&
                      "iso-8859-1" === n &&
                      (c = interpretNumericEntities(c)),
                    d.indexOf("[]=") > -1 && (c = isArray(c) ? [c] : c);
                  var f = has.call(r, p);
                  f && "combine" === t.duplicates
                    ? (r[p] = utils.combine(r[p], c))
                    : (f && "last" !== t.duplicates) || (r[p] = c);
                }
              return r;
            },
            parseObject = function (e, t, r, a) {
              for (
                var i = a ? t : parseArrayValue(t, r), o = e.length - 1;
                o >= 0;
                --o
              ) {
                var l,
                  s = e[o];
                if ("[]" === s && r.parseArrays)
                  l =
                    r.allowEmptyArrays &&
                    ("" === i || (r.strictNullHandling && null === i))
                      ? []
                      : [].concat(i);
                else {
                  l = r.plainObjects ? Object.create(null) : {};
                  var n =
                      "[" === s.charAt(0) && "]" === s.charAt(s.length - 1)
                        ? s.slice(1, -1)
                        : s,
                    p = r.decodeDotInKeys ? n.replace(/%2E/g, ".") : n,
                    c = parseInt(p, 10);
                  r.parseArrays || "" !== p
                    ? !isNaN(c) &&
                      s !== p &&
                      String(c) === p &&
                      c >= 0 &&
                      r.parseArrays &&
                      c <= r.arrayLimit
                      ? ((l = [])[c] = i)
                      : "__proto__" !== p && (l[p] = i)
                    : (l = { 0: i });
                }
                i = l;
              }
              return i;
            },
            parseKeys = function parseQueryStringKeys(e, t, r, a) {
              if (e) {
                var i = r.allowDots ? e.replace(/\.([^.[]+)/g, "[$1]") : e,
                  o = /(\[[^[\]]*])/g,
                  l = r.depth > 0 && /(\[[^[\]]*])/.exec(i),
                  s = l ? i.slice(0, l.index) : i,
                  n = [];
                if (s) {
                  if (
                    !r.plainObjects &&
                    has.call(Object.prototype, s) &&
                    !r.allowPrototypes
                  )
                    return;
                  n.push(s);
                }
                for (
                  var p = 0;
                  r.depth > 0 && null !== (l = o.exec(i)) && p < r.depth;

                ) {
                  if (
                    ((p += 1),
                    !r.plainObjects &&
                      has.call(Object.prototype, l[1].slice(1, -1)) &&
                      !r.allowPrototypes)
                  )
                    return;
                  n.push(l[1]);
                }
                return (
                  l && n.push("[" + i.slice(l.index) + "]"),
                  parseObject(n, t, r, a)
                );
              }
            },
            normalizeParseOptions = function normalizeParseOptions(e) {
              if (!e) return defaults;
              if (
                void 0 !== e.allowEmptyArrays &&
                "boolean" != typeof e.allowEmptyArrays
              )
                throw new TypeError(
                  "`allowEmptyArrays` option can only be `true` or `false`, when provided"
                );
              if (
                void 0 !== e.decodeDotInKeys &&
                "boolean" != typeof e.decodeDotInKeys
              )
                throw new TypeError(
                  "`decodeDotInKeys` option can only be `true` or `false`, when provided"
                );
              if (
                null !== e.decoder &&
                void 0 !== e.decoder &&
                "function" != typeof e.decoder
              )
                throw new TypeError("Decoder has to be a function.");
              if (
                void 0 !== e.charset &&
                "utf-8" !== e.charset &&
                "iso-8859-1" !== e.charset
              )
                throw new TypeError(
                  "The charset option must be either utf-8, iso-8859-1, or undefined"
                );
              var t = void 0 === e.charset ? defaults.charset : e.charset,
                r =
                  void 0 === e.duplicates ? defaults.duplicates : e.duplicates;
              if ("combine" !== r && "first" !== r && "last" !== r)
                throw new TypeError(
                  "The duplicates option must be either combine, first, or last"
                );
              return {
                allowDots:
                  void 0 === e.allowDots
                    ? !0 === e.decodeDotInKeys || defaults.allowDots
                    : !!e.allowDots,
                allowEmptyArrays:
                  "boolean" == typeof e.allowEmptyArrays
                    ? !!e.allowEmptyArrays
                    : defaults.allowEmptyArrays,
                allowPrototypes:
                  "boolean" == typeof e.allowPrototypes
                    ? e.allowPrototypes
                    : defaults.allowPrototypes,
                allowSparse:
                  "boolean" == typeof e.allowSparse
                    ? e.allowSparse
                    : defaults.allowSparse,
                arrayLimit:
                  "number" == typeof e.arrayLimit
                    ? e.arrayLimit
                    : defaults.arrayLimit,
                charset: t,
                charsetSentinel:
                  "boolean" == typeof e.charsetSentinel
                    ? e.charsetSentinel
                    : defaults.charsetSentinel,
                comma: "boolean" == typeof e.comma ? e.comma : defaults.comma,
                decodeDotInKeys:
                  "boolean" == typeof e.decodeDotInKeys
                    ? e.decodeDotInKeys
                    : defaults.decodeDotInKeys,
                decoder:
                  "function" == typeof e.decoder ? e.decoder : defaults.decoder,
                delimiter:
                  "string" == typeof e.delimiter || utils.isRegExp(e.delimiter)
                    ? e.delimiter
                    : defaults.delimiter,
                depth:
                  "number" == typeof e.depth || !1 === e.depth
                    ? +e.depth
                    : defaults.depth,
                duplicates: r,
                ignoreQueryPrefix: !0 === e.ignoreQueryPrefix,
                interpretNumericEntities:
                  "boolean" == typeof e.interpretNumericEntities
                    ? e.interpretNumericEntities
                    : defaults.interpretNumericEntities,
                parameterLimit:
                  "number" == typeof e.parameterLimit
                    ? e.parameterLimit
                    : defaults.parameterLimit,
                parseArrays: !1 !== e.parseArrays,
                plainObjects:
                  "boolean" == typeof e.plainObjects
                    ? e.plainObjects
                    : defaults.plainObjects,
                strictNullHandling:
                  "boolean" == typeof e.strictNullHandling
                    ? e.strictNullHandling
                    : defaults.strictNullHandling,
              };
            };
          module.exports = function (e, t) {
            var r = normalizeParseOptions(t);
            if ("" === e || null == e)
              return r.plainObjects ? Object.create(null) : {};
            for (
              var a = "string" == typeof e ? parseValues(e, r) : e,
                i = r.plainObjects ? Object.create(null) : {},
                o = Object.keys(a),
                l = 0;
              l < o.length;
              ++l
            ) {
              var s = o[l],
                n = parseKeys(s, a[s], r, "string" == typeof e);
              i = utils.merge(i, n, r);
            }
            return !0 === r.allowSparse ? i : utils.compact(i);
          };
        },
        { 5: 5 },
      ],
      4: [
        function (require, module, exports) {
          "use strict";
          var getSideChannel = require(29),
            utils = require(5),
            formats = require(1),
            has = Object.prototype.hasOwnProperty,
            arrayPrefixGenerators = {
              brackets: function brackets(e) {
                return e + "[]";
              },
              comma: "comma",
              indices: function indices(e, r) {
                return e + "[" + r + "]";
              },
              repeat: function repeat(e) {
                return e;
              },
            },
            isArray = Array.isArray,
            push = Array.prototype.push,
            pushToArray = function (e, r) {
              push.apply(e, isArray(r) ? r : [r]);
            },
            toISO = Date.prototype.toISOString,
            defaultFormat = formats.default,
            defaults = {
              addQueryPrefix: !1,
              allowDots: !1,
              allowEmptyArrays: !1,
              arrayFormat: "indices",
              charset: "utf-8",
              charsetSentinel: !1,
              delimiter: "&",
              encode: !0,
              encodeDotInKeys: !1,
              encoder: utils.encode,
              encodeValuesOnly: !1,
              format: defaultFormat,
              formatter: formats.formatters[defaultFormat],
              indices: !1,
              serializeDate: function serializeDate(e) {
                return toISO.call(e);
              },
              skipNulls: !1,
              strictNullHandling: !1,
            },
            isNonNullishPrimitive = function isNonNullishPrimitive(e) {
              return (
                "string" == typeof e ||
                "number" == typeof e ||
                "boolean" == typeof e ||
                "symbol" == typeof e ||
                "bigint" == typeof e
              );
            },
            sentinel = {},
            stringify = function stringify(
              e,
              r,
              t,
              o,
              a,
              n,
              i,
              l,
              s,
              f,
              u,
              d,
              y,
              c,
              p,
              m,
              h,
              v
            ) {
              for (
                var w = e, b = v, g = 0, A = !1;
                void 0 !== (b = b.get(sentinel)) && !A;

              ) {
                var D = b.get(e);
                if (((g += 1), void 0 !== D)) {
                  if (D === g) throw new RangeError("Cyclic object value");
                  A = !0;
                }
                void 0 === b.get(sentinel) && (g = 0);
              }
              if (
                ("function" == typeof f
                  ? (w = f(r, w))
                  : w instanceof Date
                  ? (w = y(w))
                  : "comma" === t &&
                    isArray(w) &&
                    (w = utils.maybeMap(w, function (e) {
                      return e instanceof Date ? y(e) : e;
                    })),
                null === w)
              ) {
                if (n) return s && !m ? s(r, defaults.encoder, h, "key", c) : r;
                w = "";
              }
              if (isNonNullishPrimitive(w) || utils.isBuffer(w))
                return s
                  ? [
                      p(m ? r : s(r, defaults.encoder, h, "key", c)) +
                        "=" +
                        p(s(w, defaults.encoder, h, "value", c)),
                    ]
                  : [p(r) + "=" + p(String(w))];
              var E,
                N = [];
              if (void 0 === w) return N;
              if ("comma" === t && isArray(w))
                m && s && (w = utils.maybeMap(w, s)),
                  (E = [
                    { value: w.length > 0 ? w.join(",") || null : void 0 },
                  ]);
              else if (isArray(f)) E = f;
              else {
                var S = Object.keys(w);
                E = u ? S.sort(u) : S;
              }
              var O = l ? r.replace(/\./g, "%2E") : r,
                T = o && isArray(w) && 1 === w.length ? O + "[]" : O;
              if (a && isArray(w) && 0 === w.length) return T + "[]";
              for (var k = 0; k < E.length; ++k) {
                var I = E[k],
                  P =
                    "object" == typeof I && void 0 !== I.value ? I.value : w[I];
                if (!i || null !== P) {
                  var x = d && l ? I.replace(/\./g, "%2E") : I,
                    z = isArray(w)
                      ? "function" == typeof t
                        ? t(T, x)
                        : T
                      : T + (d ? "." + x : "[" + x + "]");
                  v.set(e, g);
                  var K = getSideChannel();
                  K.set(sentinel, v),
                    pushToArray(
                      N,
                      stringify(
                        P,
                        z,
                        t,
                        o,
                        a,
                        n,
                        i,
                        l,
                        "comma" === t && m && isArray(w) ? null : s,
                        f,
                        u,
                        d,
                        y,
                        c,
                        p,
                        m,
                        h,
                        K
                      )
                    );
                }
              }
              return N;
            },
            normalizeStringifyOptions = function normalizeStringifyOptions(e) {
              if (!e) return defaults;
              if (
                void 0 !== e.allowEmptyArrays &&
                "boolean" != typeof e.allowEmptyArrays
              )
                throw new TypeError(
                  "`allowEmptyArrays` option can only be `true` or `false`, when provided"
                );
              if (
                void 0 !== e.encodeDotInKeys &&
                "boolean" != typeof e.encodeDotInKeys
              )
                throw new TypeError(
                  "`encodeDotInKeys` option can only be `true` or `false`, when provided"
                );
              if (
                null !== e.encoder &&
                void 0 !== e.encoder &&
                "function" != typeof e.encoder
              )
                throw new TypeError("Encoder has to be a function.");
              var r = e.charset || defaults.charset;
              if (
                void 0 !== e.charset &&
                "utf-8" !== e.charset &&
                "iso-8859-1" !== e.charset
              )
                throw new TypeError(
                  "The charset option must be either utf-8, iso-8859-1, or undefined"
                );
              var t = formats.default;
              if (void 0 !== e.format) {
                if (!has.call(formats.formatters, e.format))
                  throw new TypeError("Unknown format option provided.");
                t = e.format;
              }
              var o,
                a = formats.formatters[t],
                n = defaults.filter;
              if (
                (("function" == typeof e.filter || isArray(e.filter)) &&
                  (n = e.filter),
                (o =
                  e.arrayFormat in arrayPrefixGenerators
                    ? e.arrayFormat
                    : "indices" in e
                    ? e.indices
                      ? "indices"
                      : "repeat"
                    : defaults.arrayFormat),
                "commaRoundTrip" in e && "boolean" != typeof e.commaRoundTrip)
              )
                throw new TypeError(
                  "`commaRoundTrip` must be a boolean, or absent"
                );
              var i =
                void 0 === e.allowDots
                  ? !0 === e.encodeDotInKeys || defaults.allowDots
                  : !!e.allowDots;
              return {
                addQueryPrefix:
                  "boolean" == typeof e.addQueryPrefix
                    ? e.addQueryPrefix
                    : defaults.addQueryPrefix,
                allowDots: i,
                allowEmptyArrays:
                  "boolean" == typeof e.allowEmptyArrays
                    ? !!e.allowEmptyArrays
                    : defaults.allowEmptyArrays,
                arrayFormat: o,
                charset: r,
                charsetSentinel:
                  "boolean" == typeof e.charsetSentinel
                    ? e.charsetSentinel
                    : defaults.charsetSentinel,
                commaRoundTrip: e.commaRoundTrip,
                delimiter:
                  void 0 === e.delimiter ? defaults.delimiter : e.delimiter,
                encode:
                  "boolean" == typeof e.encode ? e.encode : defaults.encode,
                encodeDotInKeys:
                  "boolean" == typeof e.encodeDotInKeys
                    ? e.encodeDotInKeys
                    : defaults.encodeDotInKeys,
                encoder:
                  "function" == typeof e.encoder ? e.encoder : defaults.encoder,
                encodeValuesOnly:
                  "boolean" == typeof e.encodeValuesOnly
                    ? e.encodeValuesOnly
                    : defaults.encodeValuesOnly,
                filter: n,
                format: t,
                formatter: a,
                serializeDate:
                  "function" == typeof e.serializeDate
                    ? e.serializeDate
                    : defaults.serializeDate,
                skipNulls:
                  "boolean" == typeof e.skipNulls
                    ? e.skipNulls
                    : defaults.skipNulls,
                sort: "function" == typeof e.sort ? e.sort : null,
                strictNullHandling:
                  "boolean" == typeof e.strictNullHandling
                    ? e.strictNullHandling
                    : defaults.strictNullHandling,
              };
            };
          module.exports = function (e, r) {
            var t,
              o = e,
              a = normalizeStringifyOptions(r);
            "function" == typeof a.filter
              ? (o = (0, a.filter)("", o))
              : isArray(a.filter) && (t = a.filter);
            var n = [];
            if ("object" != typeof o || null === o) return "";
            var i = arrayPrefixGenerators[a.arrayFormat],
              l = "comma" === i && a.commaRoundTrip;
            t || (t = Object.keys(o)), a.sort && t.sort(a.sort);
            for (var s = getSideChannel(), f = 0; f < t.length; ++f) {
              var u = t[f];
              (a.skipNulls && null === o[u]) ||
                pushToArray(
                  n,
                  stringify(
                    o[u],
                    u,
                    i,
                    l,
                    a.allowEmptyArrays,
                    a.strictNullHandling,
                    a.skipNulls,
                    a.encodeDotInKeys,
                    a.encode ? a.encoder : null,
                    a.filter,
                    a.sort,
                    a.allowDots,
                    a.serializeDate,
                    a.format,
                    a.formatter,
                    a.encodeValuesOnly,
                    a.charset,
                    s
                  )
                );
            }
            var d = n.join(a.delimiter),
              y = !0 === a.addQueryPrefix ? "?" : "";
            return (
              a.charsetSentinel &&
                ("iso-8859-1" === a.charset
                  ? (y += "utf8=%26%2310003%3B&")
                  : (y += "utf8=%E2%9C%93&")),
              d.length > 0 ? y + d : ""
            );
          };
        },
        { 1: 1, 29: 29, 5: 5 },
      ],
      5: [
        function (require, module, exports) {
          "use strict";
          var formats = require(1),
            has = Object.prototype.hasOwnProperty,
            isArray = Array.isArray,
            hexTable = (function () {
              for (var e = [], r = 0; r < 256; ++r)
                e.push(
                  "%" + ((r < 16 ? "0" : "") + r.toString(16)).toUpperCase()
                );
              return e;
            })(),
            compactQueue = function compactQueue(e) {
              for (; e.length > 1; ) {
                var r = e.pop(),
                  t = r.obj[r.prop];
                if (isArray(t)) {
                  for (var o = [], n = 0; n < t.length; ++n)
                    void 0 !== t[n] && o.push(t[n]);
                  r.obj[r.prop] = o;
                }
              }
            },
            arrayToObject = function arrayToObject(e, r) {
              for (
                var t = r && r.plainObjects ? Object.create(null) : {}, o = 0;
                o < e.length;
                ++o
              )
                void 0 !== e[o] && (t[o] = e[o]);
              return t;
            },
            merge = function merge(e, r, t) {
              if (!r) return e;
              if ("object" != typeof r) {
                if (isArray(e)) e.push(r);
                else {
                  if (!e || "object" != typeof e) return [e, r];
                  ((t && (t.plainObjects || t.allowPrototypes)) ||
                    !has.call(Object.prototype, r)) &&
                    (e[r] = !0);
                }
                return e;
              }
              if (!e || "object" != typeof e) return [e].concat(r);
              var o = e;
              return (
                isArray(e) && !isArray(r) && (o = arrayToObject(e, t)),
                isArray(e) && isArray(r)
                  ? (r.forEach(function (r, o) {
                      if (has.call(e, o)) {
                        var n = e[o];
                        n && "object" == typeof n && r && "object" == typeof r
                          ? (e[o] = merge(n, r, t))
                          : e.push(r);
                      } else e[o] = r;
                    }),
                    e)
                  : Object.keys(r).reduce(function (e, o) {
                      var n = r[o];
                      return (
                        has.call(e, o)
                          ? (e[o] = merge(e[o], n, t))
                          : (e[o] = n),
                        e
                      );
                    }, o)
              );
            },
            assign = function assignSingleSource(e, r) {
              return Object.keys(r).reduce(function (e, t) {
                return (e[t] = r[t]), e;
              }, e);
            },
            decode = function (e, r, t) {
              var o = e.replace(/\+/g, " ");
              if ("iso-8859-1" === t)
                return o.replace(/%[0-9a-f]{2}/gi, unescape);
              try {
                return decodeURIComponent(o);
              } catch (e) {
                return o;
              }
            },
            limit = 1024,
            encode = function encode(e, r, t, o, n) {
              if (0 === e.length) return e;
              var a = e;
              if (
                ("symbol" == typeof e
                  ? (a = Symbol.prototype.toString.call(e))
                  : "string" != typeof e && (a = String(e)),
                "iso-8859-1" === t)
              )
                return escape(a).replace(/%u[0-9a-f]{4}/gi, function (e) {
                  return "%26%23" + parseInt(e.slice(2), 16) + "%3B";
                });
              for (var c = "", i = 0; i < a.length; i += limit) {
                for (
                  var u = a.length >= limit ? a.slice(i, i + limit) : a,
                    p = [],
                    s = 0;
                  s < u.length;
                  ++s
                ) {
                  var f = u.charCodeAt(s);
                  45 === f ||
                  46 === f ||
                  95 === f ||
                  126 === f ||
                  (f >= 48 && f <= 57) ||
                  (f >= 65 && f <= 90) ||
                  (f >= 97 && f <= 122) ||
                  (n === formats.RFC1738 && (40 === f || 41 === f))
                    ? (p[p.length] = u.charAt(s))
                    : f < 128
                    ? (p[p.length] = hexTable[f])
                    : f < 2048
                    ? (p[p.length] =
                        hexTable[192 | (f >> 6)] + hexTable[128 | (63 & f)])
                    : f < 55296 || f >= 57344
                    ? (p[p.length] =
                        hexTable[224 | (f >> 12)] +
                        hexTable[128 | ((f >> 6) & 63)] +
                        hexTable[128 | (63 & f)])
                    : ((s += 1),
                      (f =
                        65536 +
                        (((1023 & f) << 10) | (1023 & u.charCodeAt(s)))),
                      (p[p.length] =
                        hexTable[240 | (f >> 18)] +
                        hexTable[128 | ((f >> 12) & 63)] +
                        hexTable[128 | ((f >> 6) & 63)] +
                        hexTable[128 | (63 & f)]));
                }
                c += p.join("");
              }
              return c;
            },
            compact = function compact(e) {
              for (
                var r = [{ obj: { o: e }, prop: "o" }], t = [], o = 0;
                o < r.length;
                ++o
              )
                for (
                  var n = r[o], a = n.obj[n.prop], c = Object.keys(a), i = 0;
                  i < c.length;
                  ++i
                ) {
                  var u = c[i],
                    p = a[u];
                  "object" == typeof p &&
                    null !== p &&
                    -1 === t.indexOf(p) &&
                    (r.push({ obj: a, prop: u }), t.push(p));
                }
              return compactQueue(r), e;
            },
            isRegExp = function isRegExp(e) {
              return "[object RegExp]" === Object.prototype.toString.call(e);
            },
            isBuffer = function isBuffer(e) {
              return !(
                !e ||
                "object" != typeof e ||
                !(
                  e.constructor &&
                  e.constructor.isBuffer &&
                  e.constructor.isBuffer(e)
                )
              );
            },
            combine = function combine(e, r) {
              return [].concat(e, r);
            },
            maybeMap = function maybeMap(e, r) {
              if (isArray(e)) {
                for (var t = [], o = 0; o < e.length; o += 1) t.push(r(e[o]));
                return t;
              }
              return r(e);
            };
          module.exports = {
            /* common-shake removed: arrayToObject:arrayToObject */ /* common-shake removed: assign:assign */ combine:
              combine,
            compact: compact,
            decode: decode,
            encode: encode,
            isBuffer: isBuffer,
            isRegExp: isRegExp,
            maybeMap: maybeMap,
            merge: merge,
          };
        },
        { 1: 1 },
      ],
      29: [
        function (require, module, exports) {
          "use strict";
          var GetIntrinsic = require(20),
            callBound = require(7),
            inspect = require(27),
            $TypeError = require(16),
            $WeakMap = GetIntrinsic("%WeakMap%", !0),
            $Map = GetIntrinsic("%Map%", !0),
            $weakMapGet = callBound("WeakMap.prototype.get", !0),
            $weakMapSet = callBound("WeakMap.prototype.set", !0),
            $weakMapHas = callBound("WeakMap.prototype.has", !0),
            $mapGet = callBound("Map.prototype.get", !0),
            $mapSet = callBound("Map.prototype.set", !0),
            $mapHas = callBound("Map.prototype.has", !0),
            listGetNode = function (e, t) {
              for (var n, a = e; null !== (n = a.next); a = n)
                if (n.key === t)
                  return (a.next = n.next), (n.next = e.next), (e.next = n), n;
            },
            listGet = function (e, t) {
              var n = listGetNode(e, t);
              return n && n.value;
            },
            listSet = function (e, t, n) {
              var a = listGetNode(e, t);
              a ? (a.value = n) : (e.next = { key: t, next: e.next, value: n });
            },
            listHas = function (e, t) {
              return !!listGetNode(e, t);
            };
          module.exports = function getSideChannel() {
            var e,
              t,
              n,
              a = {
                assert: function (e) {
                  if (!a.has(e))
                    throw new $TypeError(
                      "Side channel does not contain " + inspect(e)
                    );
                },
                get: function (a) {
                  if (
                    $WeakMap &&
                    a &&
                    ("object" == typeof a || "function" == typeof a)
                  ) {
                    if (e) return $weakMapGet(e, a);
                  } else if ($Map) {
                    if (t) return $mapGet(t, a);
                  } else if (n) return listGet(n, a);
                },
                has: function (a) {
                  if (
                    $WeakMap &&
                    a &&
                    ("object" == typeof a || "function" == typeof a)
                  ) {
                    if (e) return $weakMapHas(e, a);
                  } else if ($Map) {
                    if (t) return $mapHas(t, a);
                  } else if (n) return listHas(n, a);
                  return !1;
                },
                set: function (a, r) {
                  $WeakMap &&
                  a &&
                  ("object" == typeof a || "function" == typeof a)
                    ? (e || (e = new $WeakMap()), $weakMapSet(e, a, r))
                    : $Map
                    ? (t || (t = new $Map()), $mapSet(t, a, r))
                    : (n || (n = { key: {}, next: null }), listSet(n, a, r));
                },
              };
            return a;
          };
        },
        { 16: 16, 20: 20, 27: 27, 7: 7 },
      ],
      6: [function (require, module, exports) {}, {}],
      7: [
        function (require, module, exports) {
          "use strict";
          var GetIntrinsic = require(20),
            callBind = require(8),
            $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
          module.exports = function callBoundIntrinsic(i, n) {
            var t = GetIntrinsic(i, !!n);
            return "function" == typeof t && $indexOf(i, ".prototype.") > -1
              ? callBind(t)
              : t;
          };
        },
        { 20: 20, 8: 8 },
      ],
      20: [
        function (require, module, exports) {
          "use strict";
          var undefined,
            $Error = require(12),
            $EvalError = require(11),
            $RangeError = require(13),
            $ReferenceError = require(14),
            $SyntaxError = require(15),
            $TypeError = require(16),
            $URIError = require(17),
            $Function = Function,
            getEvalledConstructor = function (r) {
              try {
                return $Function(
                  '"use strict"; return (' + r + ").constructor;"
                )();
              } catch (r) {}
            },
            $gOPD = Object.getOwnPropertyDescriptor;
          if ($gOPD)
            try {
              $gOPD({}, "");
            } catch (r) {
              $gOPD = null;
            }
          var throwTypeError = function () {
              throw new $TypeError();
            },
            ThrowTypeError = $gOPD
              ? (function () {
                  try {
                    return throwTypeError;
                  } catch (r) {
                    try {
                      return $gOPD(arguments, "callee").get;
                    } catch (r) {
                      return throwTypeError;
                    }
                  }
                })()
              : throwTypeError,
            hasSymbols = require(24)(),
            hasProto = require(23)(),
            getProto =
              Object.getPrototypeOf ||
              (hasProto
                ? function (r) {
                    return r.__proto__;
                  }
                : null),
            needsEval = {},
            TypedArray =
              "undefined" != typeof Uint8Array && getProto
                ? getProto(Uint8Array)
                : undefined,
            INTRINSICS = {
              __proto__: null,
              "%AggregateError%":
                "undefined" == typeof AggregateError
                  ? undefined
                  : AggregateError,
              "%Array%": Array,
              "%ArrayBuffer%":
                "undefined" == typeof ArrayBuffer ? undefined : ArrayBuffer,
              "%ArrayIteratorPrototype%":
                hasSymbols && getProto
                  ? getProto([][Symbol.iterator]())
                  : undefined,
              "%AsyncFromSyncIteratorPrototype%": undefined,
              "%AsyncFunction%": needsEval,
              "%AsyncGenerator%": needsEval,
              "%AsyncGeneratorFunction%": needsEval,
              "%AsyncIteratorPrototype%": needsEval,
              "%Atomics%": "undefined" == typeof Atomics ? undefined : Atomics,
              "%BigInt%": "undefined" == typeof BigInt ? undefined : BigInt,
              "%BigInt64Array%":
                "undefined" == typeof BigInt64Array ? undefined : BigInt64Array,
              "%BigUint64Array%":
                "undefined" == typeof BigUint64Array
                  ? undefined
                  : BigUint64Array,
              "%Boolean%": Boolean,
              "%DataView%":
                "undefined" == typeof DataView ? undefined : DataView,
              "%Date%": Date,
              "%decodeURI%": decodeURI,
              "%decodeURIComponent%": decodeURIComponent,
              "%encodeURI%": encodeURI,
              "%encodeURIComponent%": encodeURIComponent,
              "%Error%": $Error,
              "%eval%": eval,
              "%EvalError%": $EvalError,
              "%Float32Array%":
                "undefined" == typeof Float32Array ? undefined : Float32Array,
              "%Float64Array%":
                "undefined" == typeof Float64Array ? undefined : Float64Array,
              "%FinalizationRegistry%":
                "undefined" == typeof FinalizationRegistry
                  ? undefined
                  : FinalizationRegistry,
              "%Function%": $Function,
              "%GeneratorFunction%": needsEval,
              "%Int8Array%":
                "undefined" == typeof Int8Array ? undefined : Int8Array,
              "%Int16Array%":
                "undefined" == typeof Int16Array ? undefined : Int16Array,
              "%Int32Array%":
                "undefined" == typeof Int32Array ? undefined : Int32Array,
              "%isFinite%": isFinite,
              "%isNaN%": isNaN,
              "%IteratorPrototype%":
                hasSymbols && getProto
                  ? getProto(getProto([][Symbol.iterator]()))
                  : undefined,
              "%JSON%": "object" == typeof JSON ? JSON : undefined,
              "%Map%": "undefined" == typeof Map ? undefined : Map,
              "%MapIteratorPrototype%":
                "undefined" != typeof Map && hasSymbols && getProto
                  ? getProto(new Map()[Symbol.iterator]())
                  : undefined,
              "%Math%": Math,
              "%Number%": Number,
              "%Object%": Object,
              "%parseFloat%": parseFloat,
              "%parseInt%": parseInt,
              "%Promise%": "undefined" == typeof Promise ? undefined : Promise,
              "%Proxy%": "undefined" == typeof Proxy ? undefined : Proxy,
              "%RangeError%": $RangeError,
              "%ReferenceError%": $ReferenceError,
              "%Reflect%": "undefined" == typeof Reflect ? undefined : Reflect,
              "%RegExp%": RegExp,
              "%Set%": "undefined" == typeof Set ? undefined : Set,
              "%SetIteratorPrototype%":
                "undefined" != typeof Set && hasSymbols && getProto
                  ? getProto(new Set()[Symbol.iterator]())
                  : undefined,
              "%SharedArrayBuffer%":
                "undefined" == typeof SharedArrayBuffer
                  ? undefined
                  : SharedArrayBuffer,
              "%String%": String,
              "%StringIteratorPrototype%":
                hasSymbols && getProto
                  ? getProto(""[Symbol.iterator]())
                  : undefined,
              "%Symbol%": hasSymbols ? Symbol : undefined,
              "%SyntaxError%": $SyntaxError,
              "%ThrowTypeError%": ThrowTypeError,
              "%TypedArray%": TypedArray,
              "%TypeError%": $TypeError,
              "%Uint8Array%":
                "undefined" == typeof Uint8Array ? undefined : Uint8Array,
              "%Uint8ClampedArray%":
                "undefined" == typeof Uint8ClampedArray
                  ? undefined
                  : Uint8ClampedArray,
              "%Uint16Array%":
                "undefined" == typeof Uint16Array ? undefined : Uint16Array,
              "%Uint32Array%":
                "undefined" == typeof Uint32Array ? undefined : Uint32Array,
              "%URIError%": $URIError,
              "%WeakMap%": "undefined" == typeof WeakMap ? undefined : WeakMap,
              "%WeakRef%": "undefined" == typeof WeakRef ? undefined : WeakRef,
              "%WeakSet%": "undefined" == typeof WeakSet ? undefined : WeakSet,
            };
          if (getProto)
            try {
              null.error;
            } catch (r) {
              var errorProto = getProto(getProto(r));
              INTRINSICS["%Error.prototype%"] = errorProto;
            }
          var doEval = function doEval(r) {
              var e;
              if ("%AsyncFunction%" === r)
                e = getEvalledConstructor("async function () {}");
              else if ("%GeneratorFunction%" === r)
                e = getEvalledConstructor("function* () {}");
              else if ("%AsyncGeneratorFunction%" === r)
                e = getEvalledConstructor("async function* () {}");
              else if ("%AsyncGenerator%" === r) {
                var t = doEval("%AsyncGeneratorFunction%");
                t && (e = t.prototype);
              } else if ("%AsyncIteratorPrototype%" === r) {
                var o = doEval("%AsyncGenerator%");
                o && getProto && (e = getProto(o.prototype));
              }
              return (INTRINSICS[r] = e), e;
            },
            LEGACY_ALIASES = {
              __proto__: null,
              "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
              "%ArrayPrototype%": ["Array", "prototype"],
              "%ArrayProto_entries%": ["Array", "prototype", "entries"],
              "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
              "%ArrayProto_keys%": ["Array", "prototype", "keys"],
              "%ArrayProto_values%": ["Array", "prototype", "values"],
              "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
              "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
              "%AsyncGeneratorPrototype%": [
                "AsyncGeneratorFunction",
                "prototype",
                "prototype",
              ],
              "%BooleanPrototype%": ["Boolean", "prototype"],
              "%DataViewPrototype%": ["DataView", "prototype"],
              "%DatePrototype%": ["Date", "prototype"],
              "%ErrorPrototype%": ["Error", "prototype"],
              "%EvalErrorPrototype%": ["EvalError", "prototype"],
              "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
              "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
              "%FunctionPrototype%": ["Function", "prototype"],
              "%Generator%": ["GeneratorFunction", "prototype"],
              "%GeneratorPrototype%": [
                "GeneratorFunction",
                "prototype",
                "prototype",
              ],
              "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
              "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
              "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
              "%JSONParse%": ["JSON", "parse"],
              "%JSONStringify%": ["JSON", "stringify"],
              "%MapPrototype%": ["Map", "prototype"],
              "%NumberPrototype%": ["Number", "prototype"],
              "%ObjectPrototype%": ["Object", "prototype"],
              "%ObjProto_toString%": ["Object", "prototype", "toString"],
              "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
              "%PromisePrototype%": ["Promise", "prototype"],
              "%PromiseProto_then%": ["Promise", "prototype", "then"],
              "%Promise_all%": ["Promise", "all"],
              "%Promise_reject%": ["Promise", "reject"],
              "%Promise_resolve%": ["Promise", "resolve"],
              "%RangeErrorPrototype%": ["RangeError", "prototype"],
              "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
              "%RegExpPrototype%": ["RegExp", "prototype"],
              "%SetPrototype%": ["Set", "prototype"],
              "%SharedArrayBufferPrototype%": [
                "SharedArrayBuffer",
                "prototype",
              ],
              "%StringPrototype%": ["String", "prototype"],
              "%SymbolPrototype%": ["Symbol", "prototype"],
              "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
              "%TypedArrayPrototype%": ["TypedArray", "prototype"],
              "%TypeErrorPrototype%": ["TypeError", "prototype"],
              "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
              "%Uint8ClampedArrayPrototype%": [
                "Uint8ClampedArray",
                "prototype",
              ],
              "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
              "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
              "%URIErrorPrototype%": ["URIError", "prototype"],
              "%WeakMapPrototype%": ["WeakMap", "prototype"],
              "%WeakSetPrototype%": ["WeakSet", "prototype"],
            },
            bind = require(19),
            hasOwn = require(26),
            $concat = bind.call(Function.call, Array.prototype.concat),
            $spliceApply = bind.call(Function.apply, Array.prototype.splice),
            $replace = bind.call(Function.call, String.prototype.replace),
            $strSlice = bind.call(Function.call, String.prototype.slice),
            $exec = bind.call(Function.call, RegExp.prototype.exec),
            rePropName =
              /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g,
            reEscapeChar = /\\(\\)?/g,
            stringToPath = function stringToPath(r) {
              var e = $strSlice(r, 0, 1),
                t = $strSlice(r, -1);
              if ("%" === e && "%" !== t)
                throw new $SyntaxError(
                  "invalid intrinsic syntax, expected closing `%`"
                );
              if ("%" === t && "%" !== e)
                throw new $SyntaxError(
                  "invalid intrinsic syntax, expected opening `%`"
                );
              var o = [];
              return (
                $replace(r, rePropName, function (r, e, t, n) {
                  o[o.length] = t ? $replace(n, reEscapeChar, "$1") : e || r;
                }),
                o
              );
            },
            getBaseIntrinsic = function getBaseIntrinsic(r, e) {
              var t,
                o = r;
              if (
                (hasOwn(LEGACY_ALIASES, o) &&
                  (o = "%" + (t = LEGACY_ALIASES[o])[0] + "%"),
                hasOwn(INTRINSICS, o))
              ) {
                var n = INTRINSICS[o];
                if ((n === needsEval && (n = doEval(o)), void 0 === n && !e))
                  throw new $TypeError(
                    "intrinsic " +
                      r +
                      " exists, but is not available. Please file an issue!"
                  );
                return { alias: t, name: o, value: n };
              }
              throw new $SyntaxError("intrinsic " + r + " does not exist!");
            };
          module.exports = function GetIntrinsic(r, e) {
            if ("string" != typeof r || 0 === r.length)
              throw new $TypeError("intrinsic name must be a non-empty string");
            if (arguments.length > 1 && "boolean" != typeof e)
              throw new $TypeError('"allowMissing" argument must be a boolean');
            if (null === $exec(/^%?[^%]*%?$/, r))
              throw new $SyntaxError(
                "`%` may not be present anywhere but at the beginning and end of the intrinsic name"
              );
            var t = stringToPath(r),
              o = t.length > 0 ? t[0] : "",
              n = getBaseIntrinsic("%" + o + "%", e),
              a = n.name,
              y = n.value,
              i = !1,
              p = n.alias;
            p && ((o = p[0]), $spliceApply(t, $concat([0, 1], p)));
            for (var d = 1, s = !0; d < t.length; d += 1) {
              var f = t[d],
                u = $strSlice(f, 0, 1),
                l = $strSlice(f, -1);
              if (
                ('"' === u ||
                  "'" === u ||
                  "`" === u ||
                  '"' === l ||
                  "'" === l ||
                  "`" === l) &&
                u !== l
              )
                throw new $SyntaxError(
                  "property names with quotes must have matching quotes"
                );
              if (
                (("constructor" !== f && s) || (i = !0),
                hasOwn(INTRINSICS, (a = "%" + (o += "." + f) + "%")))
              )
                y = INTRINSICS[a];
              else if (null != y) {
                if (!(f in y)) {
                  if (!e)
                    throw new $TypeError(
                      "base intrinsic for " +
                        r +
                        " exists, but the property is not available."
                    );
                  return;
                }
                if ($gOPD && d + 1 >= t.length) {
                  var c = $gOPD(y, f);
                  y =
                    (s = !!c) && "get" in c && !("originalValue" in c.get)
                      ? c.get
                      : y[f];
                } else (s = hasOwn(y, f)), (y = y[f]);
                s && !i && (INTRINSICS[a] = y);
              }
            }
            return y;
          };
        },
        {
          11: 11,
          12: 12,
          13: 13,
          14: 14,
          15: 15,
          16: 16,
          17: 17,
          19: 19,
          23: 23,
          24: 24,
          26: 26,
        },
      ],
      8: [
        function (require, module, exports) {
          "use strict";
          var bind = require(19),
            GetIntrinsic = require(20),
            setFunctionLength = require(28),
            $TypeError = require(16),
            $apply = GetIntrinsic("%Function.prototype.apply%"),
            $call = GetIntrinsic("%Function.prototype.call%"),
            $reflectApply =
              GetIntrinsic("%Reflect.apply%", !0) || bind.call($call, $apply),
            $defineProperty = require(10),
            $max = GetIntrinsic("%Math.max%");
          module.exports = function callBind(e) {
            if ("function" != typeof e)
              throw new $TypeError("a function is required");
            var n = $reflectApply(bind, $call, arguments);
            return setFunctionLength(
              n,
              1 + $max(0, e.length - (arguments.length - 1)),
              !0
            );
          };
          var applyBind = function applyBind() {
            return $reflectApply(bind, $apply, arguments);
          };
          $defineProperty
            ? $defineProperty(module.exports, "apply", { value: applyBind })
            : (module.exports.apply = applyBind);
        },
        { 10: 10, 16: 16, 19: 19, 20: 20, 28: 28 },
      ],
      16: [
        function (require, module, exports) {
          "use strict";
          module.exports = TypeError;
        },
        {},
      ],
      19: [
        function (require, module, exports) {
          "use strict";
          var implementation = require(18);
          module.exports = Function.prototype.bind || implementation;
        },
        { 18: 18 },
      ],
      10: [
        function (require, module, exports) {
          "use strict";
          var GetIntrinsic = require(20),
            $defineProperty = GetIntrinsic("%Object.defineProperty%", !0) || !1;
          if ($defineProperty)
            try {
              $defineProperty({}, "a", { value: 1 });
            } catch (e) {
              $defineProperty = !1;
            }
          module.exports = $defineProperty;
        },
        { 20: 20 },
      ],
      28: [
        function (require, module, exports) {
          "use strict";
          var GetIntrinsic = require(20),
            define = require(9),
            hasDescriptors = require(22)(),
            gOPD = require(21),
            $TypeError = require(16),
            $floor = GetIntrinsic("%Math.floor%");
          module.exports = function setFunctionLength(e, r) {
            if ("function" != typeof e)
              throw new $TypeError("`fn` is not a function");
            if (
              "number" != typeof r ||
              r < 0 ||
              r > 4294967295 ||
              $floor(r) !== r
            )
              throw new $TypeError(
                "`length` must be a positive 32-bit integer"
              );
            var t = arguments.length > 2 && !!arguments[2],
              i = !0,
              n = !0;
            if ("length" in e && gOPD) {
              var o = gOPD(e, "length");
              o && !o.configurable && (i = !1), o && !o.writable && (n = !1);
            }
            return (
              (i || n || !t) &&
                (hasDescriptors
                  ? define(e, "length", r, !0, !0)
                  : define(e, "length", r)),
              e
            );
          };
        },
        { 16: 16, 20: 20, 21: 21, 22: 22, 9: 9 },
      ],
      9: [
        function (require, module, exports) {
          "use strict";
          var $defineProperty = require(10),
            $SyntaxError = require(15),
            $TypeError = require(16),
            gopd = require(21);
          module.exports = function defineDataProperty(e, r, o) {
            if (!e || ("object" != typeof e && "function" != typeof e))
              throw new $TypeError("`obj` must be an object or a function`");
            if ("string" != typeof r && "symbol" != typeof r)
              throw new $TypeError("`property` must be a string or a symbol`");
            if (
              arguments.length > 3 &&
              "boolean" != typeof arguments[3] &&
              null !== arguments[3]
            )
              throw new $TypeError(
                "`nonEnumerable`, if provided, must be a boolean or null"
              );
            if (
              arguments.length > 4 &&
              "boolean" != typeof arguments[4] &&
              null !== arguments[4]
            )
              throw new $TypeError(
                "`nonWritable`, if provided, must be a boolean or null"
              );
            if (
              arguments.length > 5 &&
              "boolean" != typeof arguments[5] &&
              null !== arguments[5]
            )
              throw new $TypeError(
                "`nonConfigurable`, if provided, must be a boolean or null"
              );
            if (arguments.length > 6 && "boolean" != typeof arguments[6])
              throw new $TypeError("`loose`, if provided, must be a boolean");
            var n = arguments.length > 3 ? arguments[3] : null,
              l = arguments.length > 4 ? arguments[4] : null,
              t = arguments.length > 5 ? arguments[5] : null,
              i = arguments.length > 6 && arguments[6],
              a = !!gopd && gopd(e, r);
            if ($defineProperty)
              $defineProperty(e, r, {
                configurable: null === t && a ? a.configurable : !t,
                enumerable: null === n && a ? a.enumerable : !n,
                value: o,
                writable: null === l && a ? a.writable : !l,
              });
            else {
              if (!i && (n || l || t))
                throw new $SyntaxError(
                  "This environment does not support defining a property as non-configurable, non-writable, or non-enumerable."
                );
              e[r] = o;
            }
          };
        },
        { 10: 10, 15: 15, 16: 16, 21: 21 },
      ],
      15: [
        function (require, module, exports) {
          "use strict";
          module.exports = SyntaxError;
        },
        {},
      ],
      21: [
        function (require, module, exports) {
          "use strict";
          var GetIntrinsic = require(20),
            $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", !0);
          if ($gOPD)
            try {
              $gOPD([], "length");
            } catch (t) {
              $gOPD = null;
            }
          module.exports = $gOPD;
        },
        { 20: 20 },
      ],
      11: [
        function (require, module, exports) {
          "use strict";
          module.exports = EvalError;
        },
        {},
      ],
      12: [
        function (require, module, exports) {
          "use strict";
          module.exports = Error;
        },
        {},
      ],
      13: [
        function (require, module, exports) {
          "use strict";
          module.exports = RangeError;
        },
        {},
      ],
      14: [
        function (require, module, exports) {
          "use strict";
          module.exports = ReferenceError;
        },
        {},
      ],
      17: [
        function (require, module, exports) {
          "use strict";
          module.exports = URIError;
        },
        {},
      ],
      18: [
        function (require, module, exports) {
          "use strict";
          var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ",
            toStr = Object.prototype.toString,
            max = Math.max,
            funcType = "[object Function]",
            concatty = function concatty(t, n) {
              for (var r = [], o = 0; o < t.length; o += 1) r[o] = t[o];
              for (var e = 0; e < n.length; e += 1) r[e + t.length] = n[e];
              return r;
            },
            slicy = function slicy(t, n) {
              for (var r = [], o = n || 0, e = 0; o < t.length; o += 1, e += 1)
                r[e] = t[o];
              return r;
            },
            joiny = function (t, n) {
              for (var r = "", o = 0; o < t.length; o += 1)
                (r += t[o]), o + 1 < t.length && (r += n);
              return r;
            };
          module.exports = function bind(t) {
            var n = this;
            if ("function" != typeof n || toStr.apply(n) !== funcType)
              throw new TypeError(ERROR_MESSAGE + n);
            for (
              var r,
                o = slicy(arguments, 1),
                e = max(0, n.length - o.length),
                i = [],
                c = 0;
              c < e;
              c++
            )
              i[c] = "$" + c;
            if (
              ((r = Function(
                "binder",
                "return function (" +
                  joiny(i, ",") +
                  "){ return binder.apply(this,arguments); }"
              )(function () {
                if (this instanceof r) {
                  var e = n.apply(this, concatty(o, arguments));
                  return Object(e) === e ? e : this;
                }
                return n.apply(t, concatty(o, arguments));
              })),
              n.prototype)
            ) {
              var p = function Empty() {};
              (p.prototype = n.prototype),
                (r.prototype = new p()),
                (p.prototype = null);
            }
            return r;
          };
        },
        {},
      ],
      23: [
        function (require, module, exports) {
          "use strict";
          var test = { __proto__: null, foo: {} },
            $Object = Object;
          module.exports = function hasProto() {
            return (
              { __proto__: test }.foo === test.foo && !(test instanceof $Object)
            );
          };
        },
        {},
      ],
      26: [
        function (require, module, exports) {
          "use strict";
          var call = Function.prototype.call,
            $hasOwn = Object.prototype.hasOwnProperty,
            bind = require(19);
          module.exports = bind.call(call, $hasOwn);
        },
        { 19: 19 },
      ],
      24: [
        function (require, module, exports) {
          "use strict";
          var origSymbol = "undefined" != typeof Symbol && Symbol,
            hasSymbolSham = require(25);
          module.exports = function hasNativeSymbols() {
            return (
              "function" == typeof origSymbol &&
              "function" == typeof Symbol &&
              "symbol" == typeof origSymbol("foo") &&
              "symbol" == typeof Symbol("bar") &&
              hasSymbolSham()
            );
          };
        },
        { 25: 25 },
      ],
      22: [
        function (require, module, exports) {
          "use strict";
          var $defineProperty = require(10),
            hasPropertyDescriptors = function hasPropertyDescriptors() {
              return !!$defineProperty;
            };
          (hasPropertyDescriptors.hasArrayLengthDefineBug =
            function hasArrayLengthDefineBug() {
              if (!$defineProperty) return null;
              try {
                return 1 !== $defineProperty([], "length", { value: 1 }).length;
              } catch (r) {
                return !0;
              }
            }),
            (module.exports = hasPropertyDescriptors);
        },
        { 10: 10 },
      ],
      25: [
        function (require, module, exports) {
          "use strict";
          module.exports = function hasSymbols() {
            if (
              "function" != typeof Symbol ||
              "function" != typeof Object.getOwnPropertySymbols
            )
              return !1;
            if ("symbol" == typeof Symbol.iterator) return !0;
            var t = {},
              e = Symbol("test"),
              r = Object(e);
            if ("string" == typeof e) return !1;
            if ("[object Symbol]" !== Object.prototype.toString.call(e))
              return !1;
            if ("[object Symbol]" !== Object.prototype.toString.call(r))
              return !1;
            for (e in ((t[e] = 42), t)) return !1;
            if ("function" == typeof Object.keys && 0 !== Object.keys(t).length)
              return !1;
            if (
              "function" == typeof Object.getOwnPropertyNames &&
              0 !== Object.getOwnPropertyNames(t).length
            )
              return !1;
            var o = Object.getOwnPropertySymbols(t);
            if (1 !== o.length || o[0] !== e) return !1;
            if (!Object.prototype.propertyIsEnumerable.call(t, e)) return !1;
            if ("function" == typeof Object.getOwnPropertyDescriptor) {
              var n = Object.getOwnPropertyDescriptor(t, e);
              if (42 !== n.value || !0 !== n.enumerable) return !1;
            }
            return !0;
          };
        },
        {},
      ],
      27: [
        function (require, module, exports) {
          (function (global) {
            (function () {
              var hasMap = "function" == typeof Map && Map.prototype,
                mapSizeDescriptor =
                  Object.getOwnPropertyDescriptor && hasMap
                    ? Object.getOwnPropertyDescriptor(Map.prototype, "size")
                    : null,
                mapSize =
                  hasMap &&
                  mapSizeDescriptor &&
                  "function" == typeof mapSizeDescriptor.get
                    ? mapSizeDescriptor.get
                    : null,
                mapForEach = hasMap && Map.prototype.forEach,
                hasSet = "function" == typeof Set && Set.prototype,
                setSizeDescriptor =
                  Object.getOwnPropertyDescriptor && hasSet
                    ? Object.getOwnPropertyDescriptor(Set.prototype, "size")
                    : null,
                setSize =
                  hasSet &&
                  setSizeDescriptor &&
                  "function" == typeof setSizeDescriptor.get
                    ? setSizeDescriptor.get
                    : null,
                setForEach = hasSet && Set.prototype.forEach,
                hasWeakMap = "function" == typeof WeakMap && WeakMap.prototype,
                weakMapHas = hasWeakMap ? WeakMap.prototype.has : null,
                hasWeakSet = "function" == typeof WeakSet && WeakSet.prototype,
                weakSetHas = hasWeakSet ? WeakSet.prototype.has : null,
                hasWeakRef = "function" == typeof WeakRef && WeakRef.prototype,
                weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null,
                booleanValueOf = Boolean.prototype.valueOf,
                objectToString = Object.prototype.toString,
                functionToString = Function.prototype.toString,
                $match = String.prototype.match,
                $slice = String.prototype.slice,
                $replace = String.prototype.replace,
                $toUpperCase = String.prototype.toUpperCase,
                $toLowerCase = String.prototype.toLowerCase,
                $test = RegExp.prototype.test,
                $concat = Array.prototype.concat,
                $join = Array.prototype.join,
                $arrSlice = Array.prototype.slice,
                $floor = Math.floor,
                bigIntValueOf =
                  "function" == typeof BigInt ? BigInt.prototype.valueOf : null,
                gOPS = Object.getOwnPropertySymbols,
                symToString =
                  "function" == typeof Symbol &&
                  "symbol" == typeof Symbol.iterator
                    ? Symbol.prototype.toString
                    : null,
                hasShammedSymbols =
                  "function" == typeof Symbol &&
                  "object" == typeof Symbol.iterator,
                toStringTag =
                  "function" == typeof Symbol &&
                  Symbol.toStringTag &&
                  (Symbol.toStringTag, 1)
                    ? Symbol.toStringTag
                    : null,
                isEnumerable = Object.prototype.propertyIsEnumerable,
                gPO =
                  ("function" == typeof Reflect
                    ? Reflect.getPrototypeOf
                    : Object.getPrototypeOf) ||
                  ([].__proto__ === Array.prototype
                    ? function (t) {
                        return t.__proto__;
                      }
                    : null);
              function addNumericSeparator(t, e) {
                if (
                  t === 1 / 0 ||
                  t === -1 / 0 ||
                  t != t ||
                  (t && t > -1e3 && t < 1e3) ||
                  $test.call(/e/, e)
                )
                  return e;
                var r = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
                if ("number" == typeof t) {
                  var n = t < 0 ? -$floor(-t) : $floor(t);
                  if (n !== t) {
                    var o = String(n),
                      i = $slice.call(e, o.length + 1);
                    return (
                      $replace.call(o, r, "$&_") +
                      "." +
                      $replace.call(
                        $replace.call(i, /([0-9]{3})/g, "$&_"),
                        /_$/,
                        ""
                      )
                    );
                  }
                }
                return $replace.call(e, r, "$&_");
              }
              var utilInspect = require(6),
                inspectCustom = utilInspect.custom,
                inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
              function wrapQuotes(t, e, r) {
                var n = "double" === (r.quoteStyle || e) ? '"' : "'";
                return n + t + n;
              }
              function quote(t) {
                return $replace.call(String(t), /"/g, "&quot;");
              }
              function isArray(t) {
                return !(
                  "[object Array]" !== toStr(t) ||
                  (toStringTag && "object" == typeof t && toStringTag in t)
                );
              }
              function isDate(t) {
                return !(
                  "[object Date]" !== toStr(t) ||
                  (toStringTag && "object" == typeof t && toStringTag in t)
                );
              }
              function isRegExp(t) {
                return !(
                  "[object RegExp]" !== toStr(t) ||
                  (toStringTag && "object" == typeof t && toStringTag in t)
                );
              }
              function isError(t) {
                return !(
                  "[object Error]" !== toStr(t) ||
                  (toStringTag && "object" == typeof t && toStringTag in t)
                );
              }
              function isString(t) {
                return !(
                  "[object String]" !== toStr(t) ||
                  (toStringTag && "object" == typeof t && toStringTag in t)
                );
              }
              function isNumber(t) {
                return !(
                  "[object Number]" !== toStr(t) ||
                  (toStringTag && "object" == typeof t && toStringTag in t)
                );
              }
              function isBoolean(t) {
                return !(
                  "[object Boolean]" !== toStr(t) ||
                  (toStringTag && "object" == typeof t && toStringTag in t)
                );
              }
              function isSymbol(t) {
                if (hasShammedSymbols)
                  return t && "object" == typeof t && t instanceof Symbol;
                if ("symbol" == typeof t) return !0;
                if (!t || "object" != typeof t || !symToString) return !1;
                try {
                  return symToString.call(t), !0;
                } catch (t) {}
                return !1;
              }
              function isBigInt(t) {
                if (!t || "object" != typeof t || !bigIntValueOf) return !1;
                try {
                  return bigIntValueOf.call(t), !0;
                } catch (t) {}
                return !1;
              }
              module.exports = function inspect_(t, e, r, n) {
                var o = e || {};
                if (
                  has(o, "quoteStyle") &&
                  "single" !== o.quoteStyle &&
                  "double" !== o.quoteStyle
                )
                  throw new TypeError(
                    'option "quoteStyle" must be "single" or "double"'
                  );
                if (
                  has(o, "maxStringLength") &&
                  ("number" == typeof o.maxStringLength
                    ? o.maxStringLength < 0 && o.maxStringLength !== 1 / 0
                    : null !== o.maxStringLength)
                )
                  throw new TypeError(
                    'option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`'
                  );
                var i = !has(o, "customInspect") || o.customInspect;
                if ("boolean" != typeof i && "symbol" !== i)
                  throw new TypeError(
                    "option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`"
                  );
                if (
                  has(o, "indent") &&
                  null !== o.indent &&
                  "\t" !== o.indent &&
                  !(parseInt(o.indent, 10) === o.indent && o.indent > 0)
                )
                  throw new TypeError(
                    'option "indent" must be "\\t", an integer > 0, or `null`'
                  );
                if (
                  has(o, "numericSeparator") &&
                  "boolean" != typeof o.numericSeparator
                )
                  throw new TypeError(
                    'option "numericSeparator", if provided, must be `true` or `false`'
                  );
                var a = o.numericSeparator;
                if (void 0 === t) return "undefined";
                if (null === t) return "null";
                if ("boolean" == typeof t) return t ? "true" : "false";
                if ("string" == typeof t) return inspectString(t, o);
                if ("number" == typeof t) {
                  if (0 === t) return 1 / 0 / t > 0 ? "0" : "-0";
                  var c = String(t);
                  return a ? addNumericSeparator(t, c) : c;
                }
                if ("bigint" == typeof t) {
                  var l = String(t) + "n";
                  return a ? addNumericSeparator(t, l) : l;
                }
                var p = void 0 === o.depth ? 5 : o.depth;
                if (
                  (void 0 === r && (r = 0),
                  r >= p && p > 0 && "object" == typeof t)
                )
                  return isArray(t) ? "[Array]" : "[Object]";
                var u = getIndent(o, r);
                if (void 0 === n) n = [];
                else if (indexOf(n, t) >= 0) return "[Circular]";
                function inspect(t, e, i) {
                  if ((e && (n = $arrSlice.call(n)).push(e), i)) {
                    var a = { depth: o.depth };
                    return (
                      has(o, "quoteStyle") && (a.quoteStyle = o.quoteStyle),
                      inspect_(t, a, r + 1, n)
                    );
                  }
                  return inspect_(t, o, r + 1, n);
                }
                if ("function" == typeof t && !isRegExp(t)) {
                  var f = nameOf(t),
                    s = arrObjKeys(t, inspect);
                  return (
                    "[Function" +
                    (f ? ": " + f : " (anonymous)") +
                    "]" +
                    (s.length > 0 ? " { " + $join.call(s, ", ") + " }" : "")
                  );
                }
                if (isSymbol(t)) {
                  var y = hasShammedSymbols
                    ? $replace.call(String(t), /^(Symbol\(.*\))_[^)]*$/, "$1")
                    : symToString.call(t);
                  return "object" != typeof t || hasShammedSymbols
                    ? y
                    : markBoxed(y);
                }
                if (isElement(t)) {
                  for (
                    var S = "<" + $toLowerCase.call(String(t.nodeName)),
                      g = t.attributes || [],
                      b = 0;
                    b < g.length;
                    b++
                  )
                    S +=
                      " " +
                      g[b].name +
                      "=" +
                      wrapQuotes(quote(g[b].value), "double", o);
                  return (
                    (S += ">"),
                    t.childNodes && t.childNodes.length && (S += "..."),
                    S + "</" + $toLowerCase.call(String(t.nodeName)) + ">"
                  );
                }
                if (isArray(t)) {
                  if (0 === t.length) return "[]";
                  var m = arrObjKeys(t, inspect);
                  return u && !singleLineValues(m)
                    ? "[" + indentedJoin(m, u) + "]"
                    : "[ " + $join.call(m, ", ") + " ]";
                }
                if (isError(t)) {
                  var h = arrObjKeys(t, inspect);
                  return "cause" in Error.prototype ||
                    !("cause" in t) ||
                    isEnumerable.call(t, "cause")
                    ? 0 === h.length
                      ? "[" + String(t) + "]"
                      : "{ [" + String(t) + "] " + $join.call(h, ", ") + " }"
                    : "{ [" +
                        String(t) +
                        "] " +
                        $join.call(
                          $concat.call("[cause]: " + inspect(t.cause), h),
                          ", "
                        ) +
                        " }";
                }
                if ("object" == typeof t && i) {
                  if (
                    inspectSymbol &&
                    "function" == typeof t[inspectSymbol] &&
                    utilInspect
                  )
                    return utilInspect(t, { depth: p - r });
                  if ("symbol" !== i && "function" == typeof t.inspect)
                    return t.inspect();
                }
                if (isMap(t)) {
                  var d = [];
                  return (
                    mapForEach &&
                      mapForEach.call(t, function (e, r) {
                        d.push(inspect(r, t, !0) + " => " + inspect(e, t));
                      }),
                    collectionOf("Map", mapSize.call(t), d, u)
                  );
                }
                if (isSet(t)) {
                  var j = [];
                  return (
                    setForEach &&
                      setForEach.call(t, function (e) {
                        j.push(inspect(e, t));
                      }),
                    collectionOf("Set", setSize.call(t), j, u)
                  );
                }
                if (isWeakMap(t)) return weakCollectionOf("WeakMap");
                if (isWeakSet(t)) return weakCollectionOf("WeakSet");
                if (isWeakRef(t)) return weakCollectionOf("WeakRef");
                if (isNumber(t)) return markBoxed(inspect(Number(t)));
                if (isBigInt(t))
                  return markBoxed(inspect(bigIntValueOf.call(t)));
                if (isBoolean(t)) return markBoxed(booleanValueOf.call(t));
                if (isString(t)) return markBoxed(inspect(String(t)));
                if ("undefined" != typeof window && t === window)
                  return "{ [object Window] }";
                if (
                  ("undefined" != typeof globalThis && t === globalThis) ||
                  ("undefined" != typeof global && t === global)
                )
                  return "{ [object globalThis] }";
                if (!isDate(t) && !isRegExp(t)) {
                  var O = arrObjKeys(t, inspect),
                    w = gPO
                      ? gPO(t) === Object.prototype
                      : t instanceof Object || t.constructor === Object,
                    $ = t instanceof Object ? "" : "null prototype",
                    k =
                      !w && toStringTag && Object(t) === t && toStringTag in t
                        ? $slice.call(toStr(t), 8, -1)
                        : $
                        ? "Object"
                        : "",
                    v =
                      (w || "function" != typeof t.constructor
                        ? ""
                        : t.constructor.name
                        ? t.constructor.name + " "
                        : "") +
                      (k || $
                        ? "[" +
                          $join.call($concat.call([], k || [], $ || []), ": ") +
                          "] "
                        : "");
                  return 0 === O.length
                    ? v + "{}"
                    : u
                    ? v + "{" + indentedJoin(O, u) + "}"
                    : v + "{ " + $join.call(O, ", ") + " }";
                }
                return String(t);
              };
              var hasOwn =
                Object.prototype.hasOwnProperty ||
                function (t) {
                  return t in this;
                };
              function has(t, e) {
                return hasOwn.call(t, e);
              }
              function toStr(t) {
                return objectToString.call(t);
              }
              function nameOf(t) {
                if (t.name) return t.name;
                var e = $match.call(
                  functionToString.call(t),
                  /^function\s*([\w$]+)/
                );
                return e ? e[1] : null;
              }
              function indexOf(t, e) {
                if (t.indexOf) return t.indexOf(e);
                for (var r = 0, n = t.length; r < n; r++)
                  if (t[r] === e) return r;
                return -1;
              }
              function isMap(t) {
                if (!mapSize || !t || "object" != typeof t) return !1;
                try {
                  mapSize.call(t);
                  try {
                    setSize.call(t);
                  } catch (t) {
                    return !0;
                  }
                  return t instanceof Map;
                } catch (t) {}
                return !1;
              }
              function isWeakMap(t) {
                if (!weakMapHas || !t || "object" != typeof t) return !1;
                try {
                  weakMapHas.call(t, weakMapHas);
                  try {
                    weakSetHas.call(t, weakSetHas);
                  } catch (t) {
                    return !0;
                  }
                  return t instanceof WeakMap;
                } catch (t) {}
                return !1;
              }
              function isWeakRef(t) {
                if (!weakRefDeref || !t || "object" != typeof t) return !1;
                try {
                  return weakRefDeref.call(t), !0;
                } catch (t) {}
                return !1;
              }
              function isSet(t) {
                if (!setSize || !t || "object" != typeof t) return !1;
                try {
                  setSize.call(t);
                  try {
                    mapSize.call(t);
                  } catch (t) {
                    return !0;
                  }
                  return t instanceof Set;
                } catch (t) {}
                return !1;
              }
              function isWeakSet(t) {
                if (!weakSetHas || !t || "object" != typeof t) return !1;
                try {
                  weakSetHas.call(t, weakSetHas);
                  try {
                    weakMapHas.call(t, weakMapHas);
                  } catch (t) {
                    return !0;
                  }
                  return t instanceof WeakSet;
                } catch (t) {}
                return !1;
              }
              function isElement(t) {
                return (
                  !(!t || "object" != typeof t) &&
                  (("undefined" != typeof HTMLElement &&
                    t instanceof HTMLElement) ||
                    ("string" == typeof t.nodeName &&
                      "function" == typeof t.getAttribute))
                );
              }
              function inspectString(t, e) {
                if (t.length > e.maxStringLength) {
                  var r = t.length - e.maxStringLength,
                    n = "... " + r + " more character" + (r > 1 ? "s" : "");
                  return (
                    inspectString($slice.call(t, 0, e.maxStringLength), e) + n
                  );
                }
                return wrapQuotes(
                  $replace.call(
                    $replace.call(t, /(['\\])/g, "\\$1"),
                    /[\x00-\x1f]/g,
                    lowbyte
                  ),
                  "single",
                  e
                );
              }
              function lowbyte(t) {
                var e = t.charCodeAt(0),
                  r = { 8: "b", 9: "t", 10: "n", 12: "f", 13: "r" }[e];
                return r
                  ? "\\" + r
                  : "\\x" +
                      (e < 16 ? "0" : "") +
                      $toUpperCase.call(e.toString(16));
              }
              function markBoxed(t) {
                return "Object(" + t + ")";
              }
              function weakCollectionOf(t) {
                return t + " { ? }";
              }
              function collectionOf(t, e, r, n) {
                return (
                  t +
                  " (" +
                  e +
                  ") {" +
                  (n ? indentedJoin(r, n) : $join.call(r, ", ")) +
                  "}"
                );
              }
              function singleLineValues(t) {
                for (var e = 0; e < t.length; e++)
                  if (indexOf(t[e], "\n") >= 0) return !1;
                return !0;
              }
              function getIndent(t, e) {
                var r;
                if ("\t" === t.indent) r = "\t";
                else {
                  if (!("number" == typeof t.indent && t.indent > 0))
                    return null;
                  r = $join.call(Array(t.indent + 1), " ");
                }
                return { base: r, prev: $join.call(Array(e + 1), r) };
              }
              function indentedJoin(t, e) {
                if (0 === t.length) return "";
                var r = "\n" + e.prev + e.base;
                return r + $join.call(t, "," + r) + "\n" + e.prev;
              }
              function arrObjKeys(t, e) {
                var r = isArray(t),
                  n = [];
                if (r) {
                  n.length = t.length;
                  for (var o = 0; o < t.length; o++)
                    n[o] = has(t, o) ? e(t[o], t) : "";
                }
                var i,
                  a = "function" == typeof gOPS ? gOPS(t) : [];
                if (hasShammedSymbols) {
                  i = {};
                  for (var c = 0; c < a.length; c++) i["$" + a[c]] = a[c];
                }
                for (var l in t)
                  has(t, l) &&
                    ((r && String(Number(l)) === l && l < t.length) ||
                      (hasShammedSymbols && i["$" + l] instanceof Symbol) ||
                      ($test.call(/[^\w$]/, l)
                        ? n.push(e(l, t) + ": " + e(t[l], t))
                        : n.push(l + ": " + e(t[l], t))));
                if ("function" == typeof gOPS)
                  for (var p = 0; p < a.length; p++)
                    isEnumerable.call(t, a[p]) &&
                      n.push("[" + e(a[p]) + "]: " + e(t[a[p]], t));
                return n;
              }
            }).call(this);
          }).call(
            this,
            typeof global !== "undefined"
              ? global
              : typeof self !== "undefined"
              ? self
              : typeof window !== "undefined"
              ? window
              : {}
          );
        },
        { 6: 6 },
      ],
    },
    {},
    [2]
  )(2);
});
